home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / MacPNG Library 1.02 / pngMacSrc 1.02 / png.1 / pnglib example.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-26  |  9.5 KB  |  361 lines  |  [TEXT/CWIE]
  1. /* example.c - an example of using libpng */
  2.  
  3. /* this is an example of how to use libpng to read and write
  4.    png files.  The file libpng.txt is much more verbose then
  5.    this.  If you have not read it, do so first.  This was
  6.    designed to be a starting point of an implementation.
  7.    This is not officially part of libpng, and therefore
  8.    does not require a copyright notice.
  9.    */
  10.  
  11. #include <png.h>
  12.  
  13. /* check to see if a file is a png file using png_check_sig() */
  14. int check_png(char *file_name)
  15. {
  16.    FILE *fp;
  17.    char buf[8];
  18.    int ret;
  19.  
  20.    fp = fopen(file_name, "rb");
  21.    if (!fp)
  22.       return 0;
  23.    ret = fread(buf, 1, 8, fp);
  24.    fclose(fp);
  25.  
  26.    if (ret != 8)
  27.       return 0;
  28.  
  29.    ret = png_check_sig(buf, 8);
  30.  
  31.    return (ret);
  32. }
  33.  
  34. /* read a png file.  You may want to return an error code if the read
  35.    fails (depending upon the failure). */
  36. void read_png(char *file_name)
  37. {
  38.    FILE *fp;
  39.    png_struct *png_ptr;
  40.    png_info *info_ptr;
  41.  
  42.    /* open the file */
  43.    fp = fopen(file_name, "rb");
  44.    if (!fp)
  45.       return;
  46.  
  47.    /* allocate the necessary structures */
  48.    png_ptr = malloc(sizeof (png_struct));
  49.    if (!png_ptr)
  50.    {
  51.       fclose(fp);
  52.       return;
  53.    }
  54.  
  55.    info_ptr = malloc(sizeof (png_info));
  56.    if (!info_ptr)
  57.    {
  58.       fclose(fp);
  59.       free(png_ptr);
  60.       return;
  61.    }
  62.  
  63.    /* set error handling */
  64.    if (setjmp(png_ptr->jmpbuf))
  65.    {
  66.       png_read_destroy(png_ptr, info_ptr, (png_info *)0);
  67.       fclose(fp);
  68.       free(png_ptr);
  69.       free(info_ptr);
  70.       /* If we get here, we had a problem reading the file */
  71.       return;
  72.    }
  73.  
  74.    /* initialize the structures, info first for error handling */
  75.    png_info_init(info_ptr);
  76.    png_read_init(png_ptr);
  77.  
  78.    /* set up the input control */
  79.    png_init_io(png_ptr, fp);
  80.  
  81.    /* read the file information */
  82.    png_read_info(png_ptr, info_ptr);
  83.  
  84.    /* allocate the memory to hold the image using the fields
  85.       of png_info. */
  86.  
  87.    /* set up the transformations you want.  Note that these are
  88.       all optional.  Only call them if you want them */
  89.  
  90.    /* expand paletted colors into true rgb */
  91.    if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
  92.       info_ptr->bit_depth < 8)
  93.       png_set_expand(png_ptr);
  94.  
  95.    /* expand grayscale images to the full 8 bits */
  96.    if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
  97.       info_ptr->bit_depth < 8)
  98.       png_set_expand(png_ptr);
  99.  
  100.    /* expand images with transparency to full alpha channels */
  101.    if (info_ptr->valid & PNG_INFO_tRNS)
  102.       png_set_expand(png_ptr);
  103.  
  104.    /* Set the background color to draw transparent and alpha
  105.       images over */
  106.    png_color_16 my_background;
  107.  
  108.    if (info_ptr->valid & PNG_INFO_bKGD)
  109.       png_set_background(png_ptr, &(info_ptr->background),
  110.          PNG_GAMMA_FILE, 1, 1.0);
  111.    else
  112.       png_set_background(png_ptr, &my_background,
  113.          PNG_GAMMA_SCREEN, 0, 1.0);
  114.  
  115.    /* tell libpng to handle the gamma conversion for you */
  116.    if (info_ptr->valid & PNG_INFO_gAMA)
  117.       png_set_gamma(png_ptr, screen_gamma, info_ptr->gamma);
  118.    else
  119.       png_set_gamma(png_ptr, screen_gamma, 0.45);
  120.  
  121.    /* tell libpng to strip 16 bit depth files down to 8 bits */
  122.    if (info_ptr->bit_depth == 16)
  123.       png_set_strip_16(png_ptr);
  124.  
  125.    /* dither rgb files down to 8 bit palettes & reduce palettes
  126.       to the number of colors available on your screen */
  127.    if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
  128.    {
  129.       if (info_ptr->valid & PNG_INFO_PLTE)
  130.          png_set_dither(png_ptr, info_ptr->palette,
  131.             info_ptr->num_palette, max_screen_colors,
  132.                info_ptr->histogram);
  133.       else
  134.       {
  135.          png_color std_color_cube[MAX_SCREEN_COLORS] =
  136.             {/* ... colors ... */};
  137.  
  138.          png_set_dither(png_ptr, std_color_cube, MAX_SCREEN_COLORS,
  139.             MAX_SCREEN_COLORS, NULL);
  140.       }
  141.    }
  142.  
  143.    /* invert monocrome files */
  144.    if (info_ptr->bit_depth == 1 &&
  145.       info_ptr->color_type == PNG_COLOR_GRAY)
  146.       png_set_invert(png_ptr);
  147.  
  148.    /* shift the pixels down to their true bit depth */
  149.    if (info_ptr->valid & PNG_INFO_sBIT &&
  150.       info_ptr->bit_depth > info_ptr->sig_bit)
  151.       png_set_shift(png_ptr, &(info_ptr->sig_bit));
  152.  
  153.    /* pack pixels into bytes */
  154.    if (info_ptr->bit_depth < 8)
  155.       png_set_packing(png_ptr);
  156.  
  157.    /* flip the rgb pixels to bgr */
  158.    if (info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
  159.       info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  160.       png_set_bgr(png_ptr);
  161.  
  162.    /* swap bytes of 16 bit files to least significant bit first */
  163.    if (info_ptr->bit_depth == 16)
  164.       png_set_swap(png_ptr);
  165.  
  166.    /* add a filler byte to store rgb files as rgbx */
  167.    if (info_ptr->bit_depth == 8 &&
  168.       info_ptr->color_type == PNG_COLOR_TYPE_RGB)
  169.       png_set_rgbx(png_ptr);
  170.  
  171.    /* optional call to update palette with transformations */
  172.    png_start_read_image(png_ptr);
  173.  
  174.    /* the easiest way to read the image */
  175.    void *row_pointers[height];
  176.    png_read_image(png_ptr, row_pointers);
  177.  
  178.    /* the other way to read images - deal with interlacing */
  179.  
  180.    /* turn on interlace handling */
  181.    if (info_ptr->interlace_type)
  182.       number_passes = png_set_interlace_handling(png_ptr);
  183.    else
  184.       number_passes = 1;
  185.  
  186.    for (pass = 0; pass < number_passes; pass++)
  187.    {
  188.       /* Read the image using the "sparkle" effect. */
  189.       png_read_rows(png_ptr, row_pointers, NULL, number_of_rows);
  190.  
  191.       /* If you are only reading on row at a time, this works */
  192.       for (y = 0; y < height; y++)
  193.       {
  194.          char *row_pointers = row[y];
  195.          png_read_rows(png_ptr, &row_pointers, NULL, 1);
  196.       }
  197.  
  198.       /* to get the rectangle effect, use the third parameter */
  199.       png_read_rows(png_ptr, NULL, row_pointers, number_of_rows);
  200.  
  201.       /* if you want to display the image after every pass, do
  202.          so here */
  203.    }
  204.  
  205.    /* read the rest of the file, getting any additional chunks
  206.       in info_ptr */
  207.    png_read_end(png_ptr, info_ptr);
  208.  
  209.    /* clean up after the read, and free any memory allocated */
  210.    png_read_destroy(png_ptr, info_ptr, (png_info *)0);
  211.  
  212.    /* free the structures */
  213.    free(png_ptr);
  214.    free(info_ptr);
  215.  
  216.    /* close the file */
  217.    fclose(fp);
  218.  
  219.    /* that's it */
  220.    return;
  221. }
  222.  
  223. /* write a png file */
  224. void write_png(char *file_name, ... other image information ...)
  225. {
  226.    FILE *fp;
  227.    png_struct *png_ptr;
  228.    png_info *info_ptr;
  229.  
  230.    /* open the file */
  231.    fp = fopen(file_name, "wb");
  232.    if (!fp)
  233.       return;
  234.  
  235.    /* allocate the necessary structures */
  236.    png_ptr = malloc(sizeof (png_struct));
  237.    if (!png_ptr)
  238.    {
  239.       fclose(fp);
  240.       return;
  241.    }
  242.  
  243.    info_ptr = malloc(sizeof (png_info));
  244.    if (!info_ptr)
  245.    {
  246.       fclose(fp);
  247.       free(png_ptr);
  248.       return;
  249.    }
  250.  
  251.    /* set error handling */
  252.    if (setjmp(png_ptr->jmpbuf))
  253.    {
  254.       png_write_destroy(png_ptr);
  255.       fclose(fp);
  256.       free(png_ptr);
  257.       free(info_ptr);
  258.       /* If we get here, we had a problem reading the file */
  259.       return;
  260.    }
  261.  
  262.    /* initialize the structures */
  263.    png_info_init(info_ptr);
  264.    png_write_init(png_ptr);
  265.  
  266.    /* set up the output control */
  267.    png_init_io(png_ptr, fp);
  268.  
  269.    /* set the file information here */
  270.    info_ptr->width = ;
  271.    info_ptr->height = ;
  272.    etc.
  273.  
  274.    /* set the palette if there is one */
  275.    info_ptr->valid |= PNG_INFO_PLTE;
  276.    info_ptr->palette = malloc(256 * sizeof (png_color));
  277.    info_ptr->num_palette = 256;
  278.    ... set palette colors ...
  279.  
  280.    /* optional significant bit chunk */
  281.    info_ptr->valid |= PNG_INFO_sBIT;
  282.    info_ptr->sig_bit = true_bit_depth;
  283.  
  284.    /* optional gamma chunk */
  285.    info_ptr->valid |= PNG_INFO_gAMA;
  286.    info_ptr->gamma = gamma;
  287.  
  288.    /* other optional chunks */
  289.  
  290.    /* write the file information */
  291.    png_write_info(png_ptr, info_ptr);
  292.  
  293.    /* set up the transformations you want.  Note that these are
  294.       all optional.  Only call them if you want them */
  295.  
  296.    /* invert monocrome pixels */
  297.    png_set_invert(png_ptr);
  298.  
  299.    /* shift the pixels up to a legal bit depth and fill in
  300.       as appropriate to correctly scale the image */
  301.    png_set_shift(png_ptr, &(info_ptr->sig_bit));
  302.  
  303.    /* pack pixels into bytes */
  304.    png_set_packing(png_ptr);
  305.  
  306.    /* flip bgr pixels to rgb */
  307.    png_set_bgr(png_ptr);
  308.  
  309.    /* swap bytes of 16 bit files to most significant bit first */
  310.    png_set_swap(png_ptr);
  311.  
  312.    /* get rid of filler bytes, pack rgb into 3 bytes */
  313.    png_set_rgbx(png_ptr);
  314.  
  315.    /* the easiest way to write the image */
  316.    void *row_pointers[height];
  317.    png_write_image(png_ptr, row_pointers);
  318.  
  319.    /* the other way to write the image - deal with interlacing */
  320.  
  321.    /* turn on interlace handling */
  322.    if (interlacing)
  323.       number_passes = png_set_interlace_handling(png_ptr);
  324.    else
  325.       number_passes = 1;
  326.  
  327.    for (pass = 0; pass < number_passes; pass++)
  328.    {
  329.       /* Write a few rows at a time. */
  330.       png_write_rows(png_ptr, row_pointers, number_of_rows);
  331.  
  332.       /* If you are only writing one row at a time, this works */
  333.       for (y = 0; y < height; y++)
  334.       {
  335.          char *row_pointers = row[y];
  336.          png_write_rows(png_ptr, &row_pointers, 1);
  337.       }
  338.    }
  339.  
  340.    /* write the rest of the file */
  341.    png_write_end(png_ptr, info_ptr);
  342.  
  343.    /* clean up after the write, and free any memory allocated */
  344.    png_write_destroy(png_ptr);
  345.  
  346.    /* if you malloced the palette, free it here */
  347.    if (info_ptr->palette)
  348.       free(info_ptr->palette);
  349.  
  350.    /* free the structures */
  351.    free(png_ptr);
  352.    free(info_ptr);
  353.  
  354.    /* close the file */
  355.    fclose(fp);
  356.  
  357.    /* that's it */
  358.    return;
  359. }
  360.  
  361.